const express = require('express');
const router = express.Router();
const Source = require('../models/Source');
const monitorService = require('../services/monitorService');
const deepSeekService = require('../services/deepSeekService');

// 获取所有采集源
router.get('/', async (req, res) => {
  try {
    const sources = await Source.find().sort({ organization: 1, name: 1 });
    res.json(sources);
  } catch (error) {
    console.error('获取采集源列表失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 获取单个采集源
router.get('/:id', async (req, res) => {
  try {
    const source = await Source.findById(req.params.id);
    if (!source) {
      return res.status(404).json({ message: '采集源不存在' });
    }
    res.json(source);
  } catch (error) {
    console.error('获取采集源详情失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 创建新采集源
router.post('/', async (req, res) => {
  try {
    const { name, listUrl, organization, selectors, proxy } = req.body;
    
    // 基本验证
    if (!name || !listUrl || !organization) {
      return res.status(400).json({ message: '名称、列表URL和组织名称为必填项' });
    }
    
    // 检查URL格式
    try {
      new URL(listUrl);
    } catch (urlError) {
      return res.status(400).json({ message: '无效的URL格式' });
    }
    
    // 检查是否已存在相同的列表URL
    const existingSource = await Source.findOne({ listUrl });
    if (existingSource) {
      return res.status(400).json({ message: '该列表URL已存在' });
    }
    
    // 创建新采集源
    const newSource = new Source({
      name,
      listUrl,
      organization,
      selectors: selectors || {},
      detailUrlPattern: req.body.detailUrlPattern || '',
      proxy: proxy || { enabled: false, host: '', port: 0 }
    });
    
    const savedSource = await newSource.save();
    res.status(201).json(savedSource);
  } catch (error) {
    console.error('创建采集源失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 更新采集源
router.put('/:id', async (req, res) => {
  try {
    const { name, listUrl, organization, selectors, status, detailUrlPattern, proxy } = req.body;
    
    // 基本验证
    if ((!name && name !== undefined) || (!listUrl && listUrl !== undefined) || (!organization && organization !== undefined)) {
      return res.status(400).json({ message: '名称、列表URL和组织名称不能为空' });
    }
    
    // 检查URL格式
    if (listUrl) {
      try {
        new URL(listUrl);
      } catch (urlError) {
        return res.status(400).json({ message: '无效的URL格式' });
      }
    }
    
    // 查找并更新采集源
    const updatedSource = await Source.findByIdAndUpdate(
      req.params.id,
      {
        ...(name && { name }),
        ...(listUrl && { listUrl }),
        ...(organization && { organization }),
        ...(selectors && { selectors }),
        ...(status && { status }),
        ...(detailUrlPattern !== undefined && { detailUrlPattern }),
        ...(proxy && { proxy }),
        updatedAt: new Date()
      },
      { new: true, runValidators: true }
    );
    
    if (!updatedSource) {
      return res.status(404).json({ message: '采集源不存在' });
    }
    
    res.json(updatedSource);
  } catch (error) {
    console.error('更新采集源失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 删除采集源
router.delete('/:id', async (req, res) => {
  try {
    const deletedSource = await Source.findByIdAndDelete(req.params.id);
    
    if (!deletedSource) {
      return res.status(404).json({ message: '采集源不存在' });
    }
    
    res.json({ message: '采集源已删除', source: deletedSource });
  } catch (error) {
    console.error('删除采集源失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 手动触发监测
router.post('/:id/monitor', async (req, res) => {
  try {
    const result = await monitorService.monitorSourceById(req.params.id);
    res.json(result);
  } catch (error) {
    console.error('手动监测采集源失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

// 使用DeepSeek AI分析网页结构
router.post('/:id/analyze-with-ai', async (req, res) => {
  try {
    const { url, useProxy } = req.body;
    
    if (!url) {
      return res.status(400).json({ message: 'URL为必填项' });
    }
    
    // 检查URL格式
    try {
      new URL(url);
    } catch (urlError) {
      return res.status(400).json({ message: '无效的URL格式' });
    }
    
    // 获取代理配置（如果需要）
    let proxyConfig = null;
    
    // 如果请求指定使用代理或者是美军网站（这些网站通常需要代理访问）
    if (useProxy || url.includes('.mil') || url.includes('.gov')) {
      // 如果有特定的源ID且不是'new'，尝试获取该源的代理配置
      if (req.params.id && req.params.id !== 'new') {
        const source = await Source.findById(req.params.id);
        if (source && source.proxy && source.proxy.enabled) {
          proxyConfig = source.proxy;
        }
      }
      
      // 如果没有源特定的代理配置，尝试使用环境变量中的全局代理配置
      if (!proxyConfig || !proxyConfig.enabled) {
        const globalProxyHost = process.env.GLOBAL_PROXY_HOST;
        const globalProxyPort = process.env.GLOBAL_PROXY_PORT;
        
        if (globalProxyHost && globalProxyPort) {
          proxyConfig = {
            enabled: true,
            host: globalProxyHost,
            port: parseInt(globalProxyPort),
            username: process.env.GLOBAL_PROXY_USERNAME || '',
            password: process.env.GLOBAL_PROXY_PASSWORD || ''
          };
          console.log('Using global proxy configuration for analysis');
        }
      }
    }
    
    // 使用DeepSeek服务分析网页，传入代理配置
    const result = await deepSeekService.analyzeWebpage(url, proxyConfig);
    
    // 如果有源ID且不是'new'，可以将分析结果应用到现有源
    if (req.params.id && req.params.id !== 'new') {
      const source = await Source.findById(req.params.id);
      if (source && result.selectors) {
        // 记录分析结果但不自动应用
        console.log(`AI analysis for source ${source.name}: `, result.selectors);
      }
    }
    
    res.json(result);
  } catch (error) {
    console.error('使用AI分析网页结构失败:', error);
    res.status(500).json({ message: 'AI分析失败', error: error.message });
  }
});

// 获取组织列表
router.get('/organizations/list', async (req, res) => {
  try {
    const organizations = await Source.distinct('organization');
    res.json(organizations);
  } catch (error) {
    console.error('获取组织列表失败:', error);
    res.status(500).json({ message: '服务器错误', error: error.message });
  }
});

module.exports = router; 